
package DB;

import Data.*;

import java.sql.PreparedStatement;
import java.rmi.RemoteException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Time;
import java.util.Vector;

/**
 * Mapper Klasse, die Flight Objekte auf eine relationale DB abbildet.
 * Ein Flight Objekt, stellt eine grobe struktur eines Fluges dar, der tatsächlich ausgeführt werden soll.
 * Das Flight Objekt definiert z.B. dass jeden Montag ein Flug von Berlin nach München um 8 Uhr abfliegt und um 10 Uhr ankommt.
 * Die tatsächliche Realisierung des Fluges erfolgt durch ein FlightRealization Objekt.
 * Diese Klasse erlaubt zahlreiche Operationen, um ein Flight zu verwalten, z.B. eine LöschOperation oder eine EinfügeOperation
 * @author Stefan Fellner
 */
public class FlightMapper {

    /*
     * Um sicher zu stellen, dass nur eine Instanz von der Klasse erzeugt wird, wird die Singleton Pattern angewendet.
     * Durch das Schlüsselwort static wird dies erreicht.
     * Quelle: http://www.theserverside.de/singleton-pattern-in-java/
     */
    private static FlightMapper flightMapper = null;

    private ConnectionManager manager;

    //mittels protected wird sichergestellt, dass mit new keine neuen Instanzen erstellt werden können. Sobals ein Mapper Objekt erstellt wird, wird eine connection aufgebaut
    protected FlightMapper(){
        manager = ConnectionManager.getInstance();

    }

    /* Eine Instanz dieser Klasse sollte immer mittels der folgenden Methode erstellt werden.
     * Dadurch wird sicher gestellt, dass nur eine Instanz von dieser Klasse vorhanden ist.
     * @return DAS <code>FlightMapper</code> Objekt
     * @see flightMapper
     */
    public static FlightMapper getInstance(){

        if(flightMapper == null){
            flightMapper = new FlightMapper();
        }

        return flightMapper;

    }


//Es folgen nun alle methoden, die die Tabelle flight verändern können, bzw. deren inhalte abrufen können


    /* Eine Flight in die Datenbank einfügen.
     * @param das Flight Objekt welches hinzugefügt werden soll. Die IDs der dazugehörigen Ankunfts- und Zielflughafen und die Airline, die den Flug ausführen werden sind bereits im flight Objekt gespeichert.
     * @return das eingefügte flug Objekt.
     * Innerhalb dieser Methode wird der Primärschlüssel automatisch erzeugt. Der größte vorhandene Schlüssel wird um 1 erhöht.
     */
    public Flight insert (Flight flight){
        //DB verbindung vom Connection Manager Objekt holen
        Connection con = this.manager.getConnection();

        try{
            // Leeres SQL-Statement (JDBC) anlegen
            Statement stmt = con.createStatement();

            /*
             * Zunächst schauen wir nach, welches der momentan größte
             * Primärschlüsselwert eines Fluges ist.
             */
            ResultSet maxId = stmt.executeQuery("SELECT MAX(flightId) AS maxId " +"FROM flight");

            //die ergebnis Tabelle muss eine maxId zurückgeben.
            if(maxId.next()){
                try{

                 //Das einzufügende Objekt flight erhält den neu errechneten Primärschlüssel
                 flight.setFlightId(maxId.getInt("maxId") + 1);

                    stmt = con.createStatement();

                     /**
                     * Jetzt erst erfolgt die tatsächliche Einfügeoperation.
                     * Die Attribute des flights, werden aus der übergebenen flight mit den getter methoden geholt.
                     */
                    stmt.executeUpdate("INSERT INTO flight (flightId, timeOfDeparture, dayOfDeparture, timeOfArrival, dayOfArrival, airportOfDeparture, airportOfArrival, airId) "+
                            "VALUES (" + "'"+
                            flight.getFlightId()+"'"+", "+"'"+
                            flight.getTimeOfDeparture()+"'"+", "+"'"+
                            flight.getDayOfDeparture()+"'"+", "+"'"+
                            flight.getTimeOfArrival()+"'"+", "+"'"+
                            flight.getDayOfArrival()+"'"+", "+"'"+
                            flight.getDepartureAirportId()+"'"+", "+"'"+
                            flight.getArrivalAirportId()+"'"+", "+"'"+
                            flight.getAirlineId()+"'"+")");
                }
                catch(RemoteException ex){
                    ex.printStackTrace();
                }
            }

        }
        //falls die sql abfrage fehlschlägt...
        catch (SQLException e2) {
            e2.printStackTrace();
        }
        //dieses return ist notwendig, da sich die ID der flight im Laufe der Methode verändert und deswegen das ganze Objekt wieder zurückgegeben wird.
        return flight;
    }







    /* Ein Flug Objekt aktualisieren.
     * Die Attribute Wochentag, TimeOfDeparture und TimeOfArrival dürfen nicht bearbeitet werden, da sonst die Plannungen mit den Aircrafts und den FlightRealizations inkonsistent werden.
     * @param das flight Objekt, mit den aktualisierten attributen
     */
     public void update (Flight flight){

         //DB verbindung vom Connection Manager Objekt holen
        Connection con = this.manager.getConnection();

        try{
            
                //sql statement
            PreparedStatement stmt = con.prepareStatement("UPDATE flight "+
                    "SET timeOfDeparture= "+"'"+flight.getTimeOfDeparture()+"'"+", "+
                    "dayOfDeparture= "+"'"+flight.getDayOfDeparture()+"'"+", "+
                    "timeOfArrival = "+"'"+flight.getTimeOfArrival()+"'"+", "+
                    "dayOfArrival = "+"'"+flight.getDayOfArrival()+"'"+", "+
                    "airportOfDeparture= "+"'"+flight.getDepartureAirportId()+"'"+", "+
                    "airportOfArrival= "+"'"+flight.getArrivalAirportId()+"'"+", "+
                    "airId= "+"'"+flight.getAirlineId()+"'"+
                    " WHERE flightId = "+"'"+flight.getFlightId()+"'");
            //dieser integer beinhaltet die anzahl der veränderten datensätze nach einer bestimmten UPDATE operation
            int anzahlVeraenderterDatensaetze = stmt.executeUpdate();
            }
            //falls der Zugriff auf die Klasse flight scheitert
            catch(RemoteException ex){
                ex.printStackTrace();
            }

        //falls die sql abfrage fehlschlägt...
        catch (SQLException e2) {
            e2.printStackTrace();
        }

     }


     /*Ein bestimmten Flug in der Datenbank löschen
      * @param der zu löschendes Flug
      */
     public void delete (Flight flight){

        //DB-Verbindung vom Connection Manager holen
        Connection con = this.manager.getConnection();

        try {
            // Leeres SQL-Statement anlegen
            Statement stmt = con.createStatement();

            stmt.executeUpdate("DELETE FROM flight "+
                               "WHERE flightId = "+"'"+flight.getFlightId()+"'");
        }
        //falls der Zugriff auf die Klasse flight fehlschlägt
        catch (RemoteException ex){
            ex.printStackTrace();
        }
        //falls der sql Befehl fehlschlägt
        catch (SQLException e2) {
            e2.printStackTrace();
        }

     }

     /*Alle Flights, die in der Tabelle vorhanden sind werden zurückgegeben
      *
      *@return Vector mit allen Flights
      */
     public Vector<Flight> findAll(){

         //DB-Verbindung vom Connection Manager holen
         Connection con = this.manager.getConnection();
         //Vector, der alle Flight Objekte festhalten wird, die in der Tabelle flight stehen
         Vector<Flight> allFlights = new Vector<Flight>();

         try{

             Statement stmt = con.createStatement();
             //das ergebnis der abfrage in ein ResultSet "Tabelle" abspeichern. D.h. jedes Tupel wird in eine Zeile des resultSets abgespeichert
             ResultSet allFlightsQueryResult = stmt.executeQuery("SELECT flightId, timeOfDeparture, dayOfDeparture, timeOfArrival, dayOfArrival, airportOfDeparture, airportOfArrival, airId FROM flight "+"ORDER BY flightId");

             //solange die ergebnisTabelle eine nachfolgende Zeile(Datensatz) hat, wird ein neues flight Objekt erstellt und zum ergebnisVector hinzugefügt.
             while(allFlightsQueryResult.next()){
                 //ein neues Flight Objekt anlegen, welches in den ergebnisvektor aufgenommen wird
                 Flight flight = new FlightImpl(allFlightsQueryResult.getString("timeOfDeparture"),
                                                allFlightsQueryResult.getString("dayOfDeparture"),
                                                allFlightsQueryResult.getString("timeOfArrival"),
                                                allFlightsQueryResult.getString("dayOfArrival"),
                                                allFlightsQueryResult.getString("airportOfDeparture"),
                                                allFlightsQueryResult.getString("airportOfArrival"),
                                                allFlightsQueryResult.getInt("airId"));
                 flight.setFlightId(allFlightsQueryResult.getInt("flightId"));

                 //das gerade erstellte Objekt wird zum Ergebnisvektor hinzugefügt
                 allFlights.addElement(flight);
             }

         }
         catch(RemoteException ex){
             ex.printStackTrace();
         }
         catch(SQLException sqlE){
             sqlE.printStackTrace();
         }
         //der vector mit allen flights aus der Tabelle wird zurückgegeben
         return allFlights;
     }

     

     /*Ein bestimmten Flight abhängig von der ID finden
      *
      * @param die FlightID als integer
      * @return das gesuchte Flight Objekt
      */

     public Flight findById(int flightId){

         //DB-Verbindung vom Connection Manager holen
         Connection con = this.manager.getConnection();

         try{

             Statement stmt = con.createStatement();

             ResultSet desiredFlight = stmt.executeQuery("SELECT flightId, timeOfDeparture, dayOfDeparture, timeOfArrival, dayOfArrival, airportOfDeparture, airportOfArrival, airId FROM flight "+
                                                           "WHERE flightId = "+"'"+flightId+"'");

             //es gibt nur ein Flight mit gleicher ID. Es wird zunächst geschaut ob, ein Flight in der ResultSet "Tabelle" ist
             if(desiredFlight.next()){
                 //den ergebnisDatensatz in ein Objekt umwandeln
                 Flight flight = new FlightImpl(desiredFlight.getString("timeOfDeparture"),
                                                desiredFlight.getString("dayOfDeparture"),
                                                desiredFlight.getString("timeOfArrival"),
                                                desiredFlight.getString("dayOfArrival"),
                                                desiredFlight.getString("airportOfDeparture"),
                                                desiredFlight.getString("airportOfArrival"),
                                                desiredFlight.getInt("airId"));
                 flight.setFlightId(desiredFlight.getInt("flightId"));
                 //das gefundene flight Objekt zurückgeben
                 return flight;
             }

         }
         //falls der Zugriff auf die Klasse flight fehlschlägt
        catch (RemoteException ex){
            ex.printStackTrace();
            return null;
        }
        //falls der sql Befehl fehlschlägt
        catch (SQLException e2) {
            e2.printStackTrace();
            return null;
        }
        //wenn kein Flight gefunden wurde und keine Fehlermeldung ausgegeben wurde, gibt die Methode null zurück.
         return null;
     }

     

     /*Alle Flüge abhängig von Time of Departure finden
      *
      * @param die time of departure als String
      * @return ein Vector mit allen zutreffenden Flight Objekt
      */

     public Vector<Flight> findByTimeOfDeparture(String timeOfDeparture){

         //DB-Verbindung vom Connection Manager holen
         Connection con = this.manager.getConnection();
         //Vector, der alle Flight Objekte festhalten wird, die in der Tabelle flight stehen
         Vector<Flight> allFlights = new Vector<Flight>();

         try{

             Statement stmt = con.createStatement();
             //das ergebnis der abfrage in ein ResultSet "Tabelle" abspeichern. D.h. jedes Tupel wird in eine Zeile des resultSets abgespeichert
             ResultSet allFlightsQueryResult = stmt.executeQuery("SELECT flightId, timeOfDeparture, dayOfDeparture, timeOfArrival, dayOfArrival, airportOfDeparture, airportOfArrival, airId FROM flight "+
                                                           "WHERE timeOfDeparture = "+"'"+timeOfDeparture+"'"+" ORDER BY flightId");

             //solange die ergebnisTabelle eine nachfolgende Zeile(Datensatz) hat, wird ein neues flight Objekt erstellt und zum ergebnisVector hinzugefügt.
             while(allFlightsQueryResult.next()){
                 //ein neues Flight Objekt anlegen, welches in den ergebnisvektor aufgenommen wird
                 Flight flight = new FlightImpl(allFlightsQueryResult.getString("timeOfDeparture"),
                                                allFlightsQueryResult.getString("dayOfDeparture"),
                                                allFlightsQueryResult.getString("timeOfArrival"),
                                                allFlightsQueryResult.getString("dayOfArrival"),
                                                allFlightsQueryResult.getString("airportOfDeparture"),
                                                allFlightsQueryResult.getString("airportOfArrival"),
                                                allFlightsQueryResult.getInt("airId"));
                 flight.setFlightId(allFlightsQueryResult.getInt("flightId"));

                 //das gerade erstellte Objekt wird zum Ergebnisvektor hinzugefügt
                 allFlights.addElement(flight);
             }

         }
         catch(RemoteException ex){
             ex.printStackTrace();
         }
         catch(SQLException sqlE){
             sqlE.printStackTrace();
         }
         //der vector mit allen flights aus der Tabelle wird zurückgegeben
         return allFlights;
     }

     /*Alle Flüge abhängig von Day of Departure finden
      *
      * @param den day of departure als String
      * @return ein Vector mit allen zutreffenden Flight Objekt
      */

     public Vector<Flight> findByDayOfDeparture(String dayOfDeparture){

         //DB-Verbindung vom Connection Manager holen
         Connection con = this.manager.getConnection();
         //Vector, der alle Flight Objekte festhalten wird, die in der Tabelle flight stehen
         Vector<Flight> allFlights = new Vector<Flight>();

         try{

             Statement stmt = con.createStatement();
             //das ergebnis der abfrage in ein ResultSet "Tabelle" abspeichern. D.h. jedes Tupel wird in eine Zeile des resultSets abgespeichert
             ResultSet allFlightsQueryResult = stmt.executeQuery("SELECT flightId, timeOfDeparture, dayOfDeparture, timeOfArrival, dayOfArrival, airportOfDeparture, airportOfArrival, airId FROM flight "+
                                                           "WHERE dayOfDeparture = "+"'"+dayOfDeparture+"'"+" ORDER BY flightId");

             //solange die ergebnisTabelle eine nachfolgende Zeile(Datensatz) hat, wird ein neues flight Objekt erstellt und zum ergebnisVector hinzugefügt.
             while(allFlightsQueryResult.next()){
                 //ein neues Flight Objekt anlegen, welches in den ergebnisvektor aufgenommen wird
                 Flight flight = new FlightImpl(allFlightsQueryResult.getString("timeOfDeparture"),
                                                allFlightsQueryResult.getString("dayOfDeparture"),
                                                allFlightsQueryResult.getString("timeOfArrival"),
                                                allFlightsQueryResult.getString("dayOfArrival"),
                                                allFlightsQueryResult.getString("airportOfDeparture"),
                                                allFlightsQueryResult.getString("airportOfArrival"),
                                                allFlightsQueryResult.getInt("airId"));
                 flight.setFlightId(allFlightsQueryResult.getInt("flightId"));

                 //das gerade erstellte Objekt wird zum Ergebnisvektor hinzugefügt
                 allFlights.addElement(flight);
             }

         }
         catch(RemoteException ex){
             ex.printStackTrace();
         }
         catch(SQLException sqlE){
             sqlE.printStackTrace();
         }
         //der vector mit allen flights aus der Tabelle wird zurückgegeben
         return allFlights;
     }

     /*Alle Flüge abhängig von Time of Arrival finden
      *
      * @param die time of arrival als String
      * @return ein Vector mit allen zutreffenden Flight Objekt
      */

     public Vector<Flight> findByTimeOfArrival(String timeOfArrival){

         //DB-Verbindung vom Connection Manager holen
         Connection con = this.manager.getConnection();
         //Vector, der alle Flight Objekte festhalten wird, die in der Tabelle flight stehen
         Vector<Flight> allFlights = new Vector<Flight>();

         try{

             Statement stmt = con.createStatement();
             //das ergebnis der abfrage in ein ResultSet "Tabelle" abspeichern. D.h. jedes Tupel wird in eine Zeile des resultSets abgespeichert
             ResultSet allFlightsQueryResult = stmt.executeQuery("SELECT flightId, timeOfDeparture, dayOfDeparture, timeOfArrival, dayOfArrival, airportOfDeparture, airportOfArrival, airId FROM flight "+
                                                           "WHERE timeOfArrival = "+"'"+timeOfArrival+"'"+" ORDER BY flightId");

             //solange die ergebnisTabelle eine nachfolgende Zeile(Datensatz) hat, wird ein neues flight Objekt erstellt und zum ergebnisVector hinzugefügt.
             while(allFlightsQueryResult.next()){
                 //ein neues Flight Objekt anlegen, welches in den ergebnisvektor aufgenommen wird
                 Flight flight = new FlightImpl(allFlightsQueryResult.getString("timeOfDeparture"),
                                                allFlightsQueryResult.getString("dayOfDeparture"),
                                                allFlightsQueryResult.getString("timeOfArrival"),
                                                allFlightsQueryResult.getString("dayOfArrival"),
                                                allFlightsQueryResult.getString("airportOfDeparture"),
                                                allFlightsQueryResult.getString("airportOfArrival"),
                                                allFlightsQueryResult.getInt("airId"));
                 flight.setFlightId(allFlightsQueryResult.getInt("flightId"));

                 //das gerade erstellte Objekt wird zum Ergebnisvektor hinzugefügt
                 allFlights.addElement(flight);
             }

         }
         catch(RemoteException ex){
             ex.printStackTrace();
         }
         catch(SQLException sqlE){
             sqlE.printStackTrace();
         }
         //der vector mit allen flights aus der Tabelle wird zurückgegeben
         return allFlights;
     }



     /*Alle Flüge abhängig von Day of Arrival finden
      *
      * @param den day of arrival als String
      * @return ein Vector mit allen zutreffenden Flight Objekt
      */

     public Vector<Flight> findByDayOfArrival(String dayOfArrival){

         //DB-Verbindung vom Connection Manager holen
         Connection con = this.manager.getConnection();
         //Vector, der alle Flight Objekte festhalten wird, die in der Tabelle flight stehen
         Vector<Flight> allFlights = new Vector<Flight>();

         try{

             Statement stmt = con.createStatement();
             //das ergebnis der abfrage in ein ResultSet "Tabelle" abspeichern. D.h. jedes Tupel wird in eine Zeile des resultSets abgespeichert
             ResultSet allFlightsQueryResult = stmt.executeQuery("SELECT flightId, timeOfDeparture, dayOfDeparture, timeOfArrival, dayOfArrival, airportOfDeparture, airportOfArrival, airId FROM flight "+
                                                           "WHERE dayOfArrival = "+"'"+dayOfArrival+"'"+" ORDER BY flightId");

             //solange die ergebnisTabelle eine nachfolgende Zeile(Datensatz) hat, wird ein neues flight Objekt erstellt und zum ergebnisVector hinzugefügt.
             while(allFlightsQueryResult.next()){
                 //ein neues Flight Objekt anlegen, welches in den ergebnisvektor aufgenommen wird
                 Flight flight = new FlightImpl(allFlightsQueryResult.getString("timeOfDeparture"),
                                                allFlightsQueryResult.getString("dayOfDeparture"),
                                                allFlightsQueryResult.getString("timeOfArrival"),
                                                allFlightsQueryResult.getString("dayOfArrival"),
                                                allFlightsQueryResult.getString("airportOfDeparture"),
                                                allFlightsQueryResult.getString("airportOfArrival"),
                                                allFlightsQueryResult.getInt("airId"));
                 flight.setFlightId(allFlightsQueryResult.getInt("flightId"));

                 //das gerade erstellte Objekt wird zum Ergebnisvektor hinzugefügt
                 allFlights.addElement(flight);
             }

         }
         catch(RemoteException ex){
             ex.printStackTrace();
         }
         catch(SQLException sqlE){
             sqlE.printStackTrace();
         }
         //der vector mit allen flights aus der Tabelle wird zurückgegeben
         return allFlights;
     }


     /*Alle Flüge abhängig von der AirportId finden
      *
      * @param die AirportId als String
      * @return ein Vector mit allen zutreffenden Flight Objekt
      */

     public Vector<Flight> findAllFlightsAssociatedWithAirport(String airportId){

         //DB-Verbindung vom Connection Manager holen
         Connection con = this.manager.getConnection();
         //Vector, der alle Flight Objekte festhalten wird, die in der Tabelle flight stehen
         Vector<Flight> allFlights = new Vector<Flight>();

         try{

             Statement stmt = con.createStatement();
             //das ergebnis der abfrage in ein ResultSet "Tabelle" abspeichern. D.h. jedes Tupel wird in eine Zeile des resultSets abgespeichert
             ResultSet allFlightsQueryResult = stmt.executeQuery("SELECT flightId, timeOfDeparture, dayOfDeparture, timeOfArrival, dayOfArrival, airportOfDeparture, airportOfArrival, airId FROM flight "+
                                                           "WHERE airportOfDeparture = "+"'"+airportId+"'"+" OR airportOfArrival = "+"'"+airportId+"'");

             //solange die ergebnisTabelle eine nachfolgende Zeile(Datensatz) hat, wird ein neues flight Objekt erstellt und zum ergebnisVector hinzugefügt.
             while(allFlightsQueryResult.next()){
                 //ein neues Flight Objekt anlegen, welches in den ergebnisvektor aufgenommen wird
                 Flight flight = new FlightImpl(allFlightsQueryResult.getString("timeOfDeparture"),
                                                allFlightsQueryResult.getString("dayOfDeparture"),
                                                allFlightsQueryResult.getString("timeOfArrival"),
                                                allFlightsQueryResult.getString("dayOfArrival"),
                                                allFlightsQueryResult.getString("airportOfDeparture"),
                                                allFlightsQueryResult.getString("airportOfArrival"),
                                                allFlightsQueryResult.getInt("airId"));
                 flight.setFlightId(allFlightsQueryResult.getInt("flightId"));

                 //das gerade erstellte Objekt wird zum Ergebnisvektor hinzugefügt
                 allFlights.addElement(flight);
             }

         }
         catch(RemoteException ex){
             ex.printStackTrace();
         }
         catch(SQLException sqlE){
             sqlE.printStackTrace();
         }
         //der vector mit allen flights aus der Tabelle wird zurückgegeben
         return allFlights;
     }


     /*Alle Flüge abhängig von der AirportId finden
      *
      * @param die AirportId als String
      * @return ein Vector mit allen zutreffenden Flight Objekt
      */

     public Vector<Flight> findAllFlightsAssociatedWithAirline(int airlineId){

         //DB-Verbindung vom Connection Manager holen
         Connection con = this.manager.getConnection();
         //Vector, der alle Flight Objekte festhalten wird, die in der Tabelle flight stehen
         Vector<Flight> allFlights = new Vector<Flight>();

         try{

             Statement stmt = con.createStatement();
             //das ergebnis der abfrage in ein ResultSet "Tabelle" abspeichern. D.h. jedes Tupel wird in eine Zeile des resultSets abgespeichert
             ResultSet allFlightsQueryResult = stmt.executeQuery("SELECT flightId, timeOfDeparture, dayOfDeparture, timeOfArrival, dayOfArrival, airportOfDeparture, airportOfArrival, airId FROM flight "+
                                                           "WHERE airId = "+"'"+airlineId+"'");

             //solange die ergebnisTabelle eine nachfolgende Zeile(Datensatz) hat, wird ein neues flight Objekt erstellt und zum ergebnisVector hinzugefügt.
             while(allFlightsQueryResult.next()){
                 //ein neues Flight Objekt anlegen, welches in den ergebnisvektor aufgenommen wird
                 Flight flight = new FlightImpl(allFlightsQueryResult.getString("timeOfDeparture"),
                                                allFlightsQueryResult.getString("dayOfDeparture"),
                                                allFlightsQueryResult.getString("timeOfArrival"),
                                                allFlightsQueryResult.getString("dayOfArrival"),
                                                allFlightsQueryResult.getString("airportOfDeparture"),
                                                allFlightsQueryResult.getString("airportOfArrival"),
                                                allFlightsQueryResult.getInt("airId"));
                 flight.setFlightId(allFlightsQueryResult.getInt("flightId"));

                 //das gerade erstellte Objekt wird zum Ergebnisvektor hinzugefügt
                 allFlights.addElement(flight);
             }

         }
         catch(RemoteException ex){
             ex.printStackTrace();
         }
         catch(SQLException sqlE){
             sqlE.printStackTrace();
         }
         //der vector mit allen flights aus der Tabelle wird zurückgegeben
         return allFlights;
     }


     /* Alle Flights, die den übergebenen airport bzw. dessen ID als Fremdschlüssel attribut haben, werden gelöscht.
      * Diese Methode wird im Zuge einer Löschung von Airports von der Verwaltung aufgerufen
      * @param die ID des airports welcher gelöscht wird
      */
     public void deleteAllFlightsWithAirportId(String airportId){
         //DB-Verbindung vom Connection Manager holen
        Connection con = this.manager.getConnection();

        try {
            // Leeres SQL-Statement anlegen
            Statement stmt = con.createStatement();

            stmt.executeUpdate("DELETE FROM flight "+
                               "WHERE airportOfDeparture = "+"'"+airportId+"'"+" OR airportOfArrival = "+"'"+airportId+"'");
        }

        //falls der sql Befehl fehlschlägt
        catch (SQLException e2) {
            e2.printStackTrace();
        }
     }


     /* Alle Flights, die der übergebenen airline bzw. dessen ID als Fremdschlüssel attribut haben, werden gelöscht.
      * Diese Methode wird im Zuge einer Löschung von Airlines von der Verwaltung aufgerufen
      * @param die ID der airline welche gelöscht wird
      */
     public void deleteAllFlightsWithAirlineId(int airId){
         //DB-Verbindung vom Connection Manager holen
        Connection con = this.manager.getConnection();

        try {
            // Leeres SQL-Statement anlegen
            Statement stmt = con.createStatement();

            stmt.executeUpdate("DELETE FROM flight "+
                               "WHERE airId = "+"'"+airId+"'");
        }

        //falls der sql Befehl fehlschlägt
        catch (SQLException e2) {
            e2.printStackTrace();
        }
     }


         /**
	 * Auslesen des zugehörigen AirportOfDeparture Objekt zu einem gegebenen
	 * Flight.
	 *
	 * @param der Flight, wessen AirportOfDeparture erfahren werden soll.
	 * @return ein Objekt, welches den AirportOfDeparture darstellt
	 */
	public Airport getDepartureAirportOfFlight(Flight flight) {
		try {
			/*
			 * Die AirportMapper Klasse wird aufgerufen bzw. deren findById Methode.
                         * Dadurch bekommen wir das gesuchte Airport Objekt zurück
			 */
                         return AirportMapper.getInstance().findByInternationalId(flight.getDepartureAirportId());

		}
		catch (RemoteException e) {
			e.printStackTrace();
			// Wenn der Zugriff auf die AirportMapper fehlschlägt, dann geben wir null zurück.
			return null;
		}
	}


        /**
	 * Auslesen des zugehörigen AirportOfArrival Objekt zu einem gegebenen
	 * Flight.
	 *
	 * @param der Flight, wessen AirportOfArrival erfahren werden soll.
	 * @return ein Objekt, welches den AirportOfArrival darstellt
	 */
	public Airport getArrivalAirportOfFlight(Flight flight) {
		try {
			/*
			 * Die AirportMapper Klasse wird aufgerufen bzw. deren findById Methode.
                         * Dadurch bekommen wir das gesuchte Airport Objekt zurück
			 */
                         return AirportMapper.getInstance().findByInternationalId(flight.getArrivalAirportId());

		}
		catch (RemoteException e) {
			e.printStackTrace();
			// Wenn der Zugriff auf die AirportMapper fehlschlägt, dann geben wir null zurück.
			return null;
		}
	}

}



